import { getObjType } from "../utils/util";
import { getSheetIndex } from "../methods/get";
import Store from "../store";

//动态数组计算
function dynamicArrayCompute(dynamicArray) {
  let dynamicArray_compute = {};

  if (getObjType(dynamicArray) == "array") {
    for (let i = 0; i < dynamicArray.length; i++) {
      let d_row = dynamicArray[i].r;
      let d_col = dynamicArray[i].c;
      let d_f = dynamicArray[i].f;

      if (
        Store.flowdata[d_row][d_col] != null &&
        Store.flowdata[d_row][d_col].f != null &&
        Store.flowdata[d_row][d_col].f == d_f
      ) {
        if (d_row + "_" + d_col in dynamicArray_compute) {
          dynamicArray_compute = dynamicArraySpillEditCompute(
            dynamicArray_compute,
            d_row,
            d_col
          );
        }

        let d_data = dynamicArray[i].data;
        let d_rowlen = d_data.length;
        let d_collen = 1;

        if (getObjType(d_data[0]) == "array") {
          d_collen = d_data[0].length;
        }

        if (
          dynamicArrayRangeIsAllNull(
            {
              row: [d_row, d_row + d_rowlen - 1],
              column: [d_col, d_col + d_collen - 1],
            },
            Store.flowdata
          )
        ) {
          for (let x = 0; x < d_rowlen; x++) {
            for (let y = 0; y < d_collen; y++) {
              let rowIndex = d_row + x;
              let colIndex = d_col + y;

              if (getObjType(d_data[0]) == "array") {
                dynamicArray_compute[rowIndex + "_" + colIndex] = {
                  v: d_data[x][y],
                  r: d_row,
                  c: d_col,
                };
              } else {
                dynamicArray_compute[rowIndex + "_" + colIndex] = {
                  v: d_data[x],
                  r: d_row,
                  c: d_col,
                };
              }
            }
          }
        } else {
          dynamicArray_compute[d_row + "_" + d_col] = {
            v: "#SPILL!",
            r: d_row,
            c: d_col,
          };
        }
      }
    }
  }

  return dynamicArray_compute;
}

function dynamicArraySpillEditCompute(computeObj, r, c) {
  let rowIndex = computeObj[r + "_" + c].r;
  let colIndex = computeObj[r + "_" + c].c;

  for (let x in computeObj) {
    if (x == rowIndex + "_" + colIndex) {
      computeObj[x].v = "#SPILL!";
    } else if (computeObj[x].r == rowIndex && computeObj[x].c == colIndex) {
      delete computeObj[x];
    }
  }

  return computeObj;
}

//范围是否都是空单元格(除第一个单元格)
function dynamicArrayRangeIsAllNull(range, data) {
  let r1 = range["row"][0],
    r2 = range["row"][1];
  let c1 = range["column"][0],
    c2 = range["column"][1];

  let isAllNull = true;
  for (let r = r1; r <= r2; r++) {
    for (let c = c1; c <= c2; c++) {
      if (
        !(r == r1 && c == c1) &&
        data[r][c] != null &&
        data[r][c].v != null &&
        data[r][c].v.toString() != ""
      ) {
        isAllNull = false;
        break;
      }
    }
  }

  return isAllNull;
}

//点击表格区域是否属于动态数组区域
function dynamicArrayHightShow(r, c) {
  let dynamicArray =
    Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)][
      "dynamicArray"
    ] == null
      ? []
      : Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)][
          "dynamicArray"
        ];
  let dynamicArray_compute = dynamicArrayCompute(dynamicArray);

  if (
    r + "_" + c in dynamicArray_compute &&
    dynamicArray_compute[r + "_" + c].v != "#SPILL!"
  ) {
    let d_row = dynamicArray_compute[r + "_" + c].r;
    let d_col = dynamicArray_compute[r + "_" + c].c;

    let d_f = Store.flowdata[d_row][d_col].f;

    let rlen, clen;
    for (let i = 0; i < dynamicArray.length; i++) {
      if (dynamicArray[i].f == d_f) {
        rlen = dynamicArray[i].data.length;

        if (getObjType(dynamicArray[i].data[0]) == "array") {
          clen = dynamicArray[i].data[0].length;
        } else {
          clen = 1;
        }
      }
    }

    let d_row_end = d_row + rlen - 1;
    let d_col_end = d_col + clen - 1;

    let row = Store.visibledatarow[d_row_end],
      row_pre = d_row - 1 == -1 ? 0 : Store.visibledatarow[d_row - 1];
    let col = Store.visibledatacolumn[d_col_end],
      col_pre = d_col - 1 == -1 ? 0 : Store.visibledatacolumn[d_col - 1];

    $("#luckysheet-dynamicArray-hightShow").css({
      left: col_pre,
      width: col - col_pre - 1,
      top: row_pre,
      height: row - row_pre - 1,
      display: "block",
    });
  } else {
    $("#luckysheet-dynamicArray-hightShow").hide();
  }
}

export {
  dynamicArrayCompute,
  dynamicArraySpillEditCompute,
  dynamicArrayRangeIsAllNull,
  dynamicArrayHightShow,
};
